Insight Generation From Statistical Measure/Dimension Combinations

ABSTRACT

Insights gleaned from statistical analysis of a dataset of an in-memory database, may be obtained with high throughput. In response to a user query, a Data Inference Engine (DIE) provides statistically valid measure/dimension combinations of the dataset to an analysis tool. A master procedure may be executed at search query runtime, allowing timely filtering of output of the analysis tool based on columns provided in the user request. Inputs/outputs of the master procedure may avoid storing physical tables, reducing maintenance. The master procedure may comprise individual sub-procedures (e.g. determining outliers, percentage contribution) executed in parallel. Output of sub-procedure(s) may be formatted per a final output format, facilitating union therebetween. Embodiments may filter certain measure/dimension combinations received from the DIE. For example, embodiments may consider only unique measure/dimension combinations (irrespective of dimension order), a limited number of combinations (e.g. ≦20), and/or combinations having a limited number of dimensions (e.g. ≦3).

BACKGROUND

Embodiments of the present invention relate to analysis of data stored in databases, and in particular to generation of ranked insight for statistically valid combinations of measures and dimensions.

Unless otherwise indicated herein, the approaches described in this section are not prior art to the claims in this application and are not admitted to be prior art by inclusion in this section.

A business problem may call for identifying relevant data within a large volume of a data warehouse, to perform analysis and create a solution strategy. Automated analysis tools may afford a user with statistical insights regarding such large data volumes.

Conventional analysis tools may provide analytical insight, but typically require frequent manual intervention by the user. This slows the process, and requires the user to exercise statistical knowledge in order to use the tool and interpret the insights provided.

To achieve favorable performance on these large datasets, many tools employ supporting intermediate physical tables. This involves maintenance with respect to durability, confidentiality, and integrity of the data.

Sequential generation of insights for each combination of data per user dataset, increases the response time with increase in number of datasets and the users. This situation may become more difficult with large datasets having many measures and dimensions.

Moreover, the overall ranking of insights may become invalid unless terms in the request inputs are considered. These terms are available only at runtime, hence pre-generated insights provided by conventional analysis tools may not be relevant to the request.

Accordingly, the present disclosure addresses these and other issues with systems and methods generating ranked insight for statistically valid combinations of measures and dimensions.

SUMMARY

Insights gleaned from statistical analysis of a dataset of an in-memory database, may be obtained with high throughput. In response to a user query, a Data Inference Engine (DIE) provides statistically valid measure/dimension combinations of the dataset to an analysis tool. A master procedure may be executed at search query runtime, allowing timely filtering of output of the analysis tool based on columns provided in the user request. Inputs/outputs of the master procedure may avoid storing physical tables, reducing maintenance. The master procedure may comprise individual sub-procedures (e.g. determining outliers, percentage contribution) executed in parallel. Output of sub-procedure(s) may be formatted per a final output format, facilitating union therebetween. Embodiments may filter certain measure/dimension combinations received from the DIE. For example, embodiments may consider only unique measure/dimension combinations (irrespective of dimension order), a limited number of combinations (e.g. ≦20), and/or combinations having a limited number of dimensions (e.g. ≦3).

An embodiment of a computer-implemented method comprises causing an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database. The insight analysis tool is caused to process the input according to a master procedure comprising a sub-procedure, in order to generate an insight, and the insight is caused to be displayed to a user.

An embodiment of a non-transitory computer readable storage medium embodies a computer program for performing a method comprising causing an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database. The insight analysis tool is caused to process the input according to a master procedure comprising a sub-procedure in order to generate an insight, the insight is caused to be displayed to a user.

An embodiment of a computer system comprises one or more processors and a software program executable on said computer system. The software program is configured to cause an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database. The software program is further configured to cause the insight analysis tool to process the input according to a master procedure comprising a sub-procedure, in order to generate an insight, and to cause the insight to be displayed to a user.

In some embodiments the input comprises a result of a user query to the in-memory database, and the insight analysis tool is caused to process the input during a runtime of the user query.

According to particular embodiments the insight analysis tool is caused to process the input according to a parameter of the user query.

In certain embodiments the insight analysis tool is further configured to generate a plurality of insights from the input, and to rank the insight relative to the plurality of insights.

In various embodiments the insight analysis tool is further configured to receive a plurality of measure/dimension combinations, and to filter the plurality of measure/dimension combinations to generate the insight.

According to particular embodiments the plurality of measure/dimension combinations comprise multiple dimensions, and filtering the plurality of measure/dimension combinations comprises limiting a number of insights, limiting a number of dimensions, and/or identifying unique measure/dimension combinations by disregarding an order in which dimensions occur.

In some embodiments the sub-procedure comprises outlier detection.

The following detailed description and accompanying drawings provide a better understanding of the nature and advantages of particular embodiments.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a simplified view showing the provisioning of datasets from an in-memory database.

FIG. 2 shows a block diagram of a master procedure according to an embodiment.

FIGS. 3A-D show a code snippet showing dynamic creation of a master procedure at runtime.

FIGS. 4A-D show code defining a master procedure according to an embodiment.

FIG. 5 shows code for a Query for obtaining a top five DYK insights from the ResultView.

FIGS. 6A-B show a code snippet for the BoxandWhisker sub-procedure according to an embodiment.

FIGS. 7A-D show a code snippet for formatting the BoxandWhisker output using LScript according to an embodiment.

FIGS. 8A-B show a code snippet for the actual SQL Percentage sub-procedure according to an embodiment.

FIGS. 9A-B show a code snippet for formatting the Percentage output using LScript according to an embodiment.

FIG. 10 is a view showing a sample dataset.

FIG. 11 is a Result View showing DYK statistical analytical insights generated for the sample dataset of FIG. 10.

FIG. 12 shows execution of the DYK generation procedure.

FIG. 12A provides a chart of a corresponding process flow.

FIG. 13 shows Key Information presented to the left of results in bar chart format.

FIG. 14 shows Key Information presented to the left of results in the format of a plotted graph.

FIG. 15 illustrates hardware of a special purpose computing machine configured to perform insight generation according to an embodiment.

FIG. 16 illustrates an example of a computer system.

DETAILED DESCRIPTION

Described herein are techniques for generating ranked insights for statistically valid combinations of measures and dimensions in a dataset. The apparatuses, methods, and techniques described below may be implemented as a computer program (software) executing on one or more computers. The computer program may further be stored on a non-transitory computer readable medium. The non-transitory computer readable medium may include instructions for performing the processes described below.

In the following description, for purposes of explanation, numerous examples and specific details are set forth in order to provide a thorough understanding of the present invention. It will be evident, however, to one skilled in the art that the present invention as defined by the claims may include some or all of the features in these examples alone or in combination with other features described below, and may further include modifications and equivalents of the features and concepts described herein.

Embodiments of the present invention may employ one or more of the following concepts, alone or in various combinations, to enhance the throughput of insight generation resulting from data analysis.

Embodiments may use stored procedures which call sub-procedures, to obtain insights for a dataset uploaded by a user. This can help in achieving the parallelization of sub procedure calls.

Embodiments may execute a stored procedure at run time during a search query. This can prevent generation of insights based upon any outdated information.

Embodiments may utilize a result view, holding the union of output from sub-procedures. This can provide the benefit of calling the procedure with select query, whose execution is faster in JavaScript as compared to a procedure call.

Embodiments may use table types for input and output tables of the stored procedures. This can help ensure that maintenance is not required, as there are no physical tables. Possible issues with data durability, confidentiality, and integrity are addressed as the insights are generated at real time and data is stored in memory.

Embodiments may implement outlier detection and percentage calculation algorithm(s) identifying out-of-the-box information from amongst the supplied data. Such outlier detection and percentage computation algorithms represent only specific examples, and other algorithms can be implemented. The purpose of such algorithms is to process the supplied data and identify out-of-the-box information (e.g. an insight) which helps the user to understand and improve his business.

In certain embodiments, a Data Inference Engine (DIE) may provide statistically valid combinations of a given dataset using data mining algorithms. Such use of combinations from a DIE avoids insight generation for any unnecessary combinations. This can reduce the response time.

Various embodiments may format the output from the sub-procedure as per the final output format. This can facilitate the union between the sub-procedure output and the final output.

Certain embodiments may filter the output of the insight analysis tool, based on the columns provided in the input request (the columns of interest to the user). Hence only those combinations in which the given columns are involved may be retained.

Embodiments may employ an internal ranking process in each sub procedure. This ranking process may add up to a final score across the sub procedures.

In some embodiments, a final score calculation technique may be based on partial match and full match, in order to provide the top insights from a returned dataset.

The following discussion provides a description of particular embodiments in connection with a “Did You Know?” analysis tool (hereafter “DYK”) used in conjunction with a HANA in-memory database, both of which are available from SAP AG of Walldorf Germany. However, embodiments are not limited to working with this or any other particular analysis tool and/or database.

FIG. 1 is a simplified view showing the provisioning of datasets 102 from an in-memory database 101. The DYK insight analysis tool 104 generates statistical insight(s) 106 from the stored data, based upon measures (M) and dimensions (D) obtained by provisioning. Provisioning is a procedure which prepares a dataset for searching. A part of the provisioning process is creation of a DYK Master procedure (DYK GEN), which uses the combinations obtained from the DIE.

In particular, the combinations of measures and dimensions (M/D) are provided by Data Inference Engine (DIE) 103. The DIE provides statically valid combinations of measures and dimensions in a dataset. In certain embodiments the DIE helps in identifying the important combinations for DYK generation, thus avoiding the usage of unnecessary combinations.

Once the master procedure has been created during the provisioning process, it is then executed during a search workflow to internally call multiple sub-procedures to finally generate the analytical insight(s) 106. In certain embodiments, these sub-procedures may be LScript or SQL Script.

The inputs from the search request are considered for filtering and ranking. This is analogous to indexing the data first. Based on a search query the ranking is applied on indexed data.

While no separate indexing is performed as such, the master procedure is created during provisioning which gets triggered during search query. Then ranking is applied on the executed result.

The DYK insight analysis tool may be implemented as software, hardware, or a combination of both software and hardware. DYK insight generation logic may be put in a master stored procedure (DYK GEN), written in SQL Script. FIG. 2 shows a simplified view of an example of this master procedure.

The particular master procedure of the embodiment of FIG. 2 shows two sub-procedures: “BoxandWhisker” and “Percentage”. As discussed in detail below, the BoxandWhisker sub-procedure is useful in identifying outlier data. The Percentage sub-procedure is useful in identifying percentages of dimensions contributing to percentages of measures.

The DYK master procedure is created per a dataset of a user. Whenever a dataset or an analytical view is provisioned, the DYK GEN Procedure is formed programmatically by running a JavaScript function in XSEngine. The User Schema and Dataset Id are appended to the name of the DYK GEN Procedure in order to keep the Procedure unique.

Inputs to the master procedure are sessionId and RequestId. Output of the master procedure is a ResultTable as a table type.

The master procedure gets compiled and created during the provisioning of the user data. The code snippet shown in FIGS. 3A-D gives the brief idea of dynamically creating the procedures at runtime.

Output from the master procedure may include output from each sub-procedure executed for each combination. With this, parsing of the DYK result from the result set in the Javascript, may become difficult with increased number of results in the result set.

According to an embodiment, the master procedure may be created with a Result View. Making use of the Result View in this manner, allows the output to be the union of output from each sub-procedure.

The master procedure is executed by firing a Select Query on the Result View, as would be the case for any other query on the table. With this, various operations like Group By, Order By, TOP, etc., are achievable. This makes the Result fetch faster.

As just mentioned, the output from each sub-procedure executed for each combination, is large in size. Where the master procedure performs a union of outputs of all the sub-procedures, the union of these large outputs can reduce a speed of execution of the master procedure.

According to particular embodiments, however, the SessionID and the RequestID of the DYK search request are passed as parameters to the master procedure. Specifically, before making the call to the master procedure, the DYK Search application would have populated the Search Control table for the user, with the SessionID, RequestID, and the ColumnIDs of the input columns.

The master procedure then uses the passed SessionID and RequestID, to filter out the data from the outputs of sub-procedures. Only that data containing the input Column IDs, are retrieved from the outputs of the sub-procedures.

The union of these filtered outputs takes less time than the union of the actual outputs of the sub-procedures. This can result in an overall performance improvement of the master procedure.

FIGS. 4A-D show code defining a master procedure according to an embodiment. FIG. 5 shows code for a Query for obtaining a top five DYK insights from the ResultView.

The master procedure receives the combination of measures and dimensions from the DIE. As shown in FIG. 2, in DYK the combination containing only one measure (1M) is considered for DYK insight generation. The intermediate tables used for computation at various levels of DYK generation are Table types, and hence the data is available in-memory.

For every combination, the input data is obtained from the user's dataset. This input Table definition is common to any type of combination. Each combination will contain one measure and one to three dimensions. Hence, a maximum number of columns in the input table is four.

The input data is generalized to suit the input table requirement. This idea avoids usage of multiple tables for different type of combination and data.

The input tables are then passed to the sub-procedures (BoxandWhisker and Percentage). These sub-procedures are used to calculate outliers and percentage of the Measures from the dataset. The sub-procedures are executed for each combination, and hence the output of these are unioned to get the final DYK output.

The BoxandWhisker sub-procedure is the implementation of outlier detection algorithm ‘BoxandWhisker’. An outlier is one that appears to deviate markedly from other members of the sample in which it occurs.

For the given list of measure Value in the input data, outliers may be detected using pseudo-code as outlined below.

1. Sort the list of measure values in an array “data_array”. 2. Take the size of the array: “total_size”. 3. Calculate q1,q2,q3, and also start, mid, and end position. 4. Set the start_pos = 0. 5. Set the end_pos = total_size−1. 6. Set the mid_pos = total_size/2. 7. Take the middle value from the data_array as: mid_value = data_array[total_size/2]. 8. Make q3_start_pos = mid_pos +1. 9. If total_size is odd, then:    q1_end_pos = mid_pos −1; q2 = mid_value (50th percentile). 10. If total_size is even, then:    a. Mid_previous_value = data_array[mid_pos − 1];    b. q2 = (mid_value + mid_previous_value)/2.(50th percentile);    c. q1_end_pos = mid_pos −1;    d. q3_start_pos = mid_pos. 11. Calculate q1 25th percentile:    a. Q1_mid = q1_en_pos−start_pos/2;    b. If q1_mid is odd, q1 = data_array[q1_mid];    c. Else , q1 = (data_array[q1_mid+1]+ data_array[q1_mid])/2; 12. Calculate q3 75th percentile:    a. Q3_mid_pos = end_pos − q3_start_pos/2;    b. Q3_mid = q3_start_pos + q3_mid;    c. If q3_mid is odd, q3 = data_array[q3_mid];    d. Else, q3 = (data_array[q3_mid −1] + data_array[q3_mid])/2. 13. Calculate IQR, iqr = q3−q1. 14. Set Ratio = 1.5. 15. Calculate quotient, quote = iqr * ratio. 16. Calculate LOWRANGE = q1−quote. 17. Calculate UPRANGE = q3+quote. 18. Filter the all values from data_array lesser than LOWRANGE and greater than UPRANGE. These are outliers.

For calculating the rank within the BoxandWhisker sub-procedure, the distance of each outlier value from the LOWRANGE and UPRANGE respectively, is computed. An example of pseudocode for rank calculation for BoxandWhisker is as follows:

1. Take the maximum distance from the outliers as max. 2. Consider the rank for maximum distance as 5 (Top rank). 3. Calculate the rank for each distance as (distance/max)*5. This will provide the ranks ranging from five (5) to one (1), with five being the top rank.

These outliers along with the rank are then formatted to match the final DYK result table definition. This formatting can be done using an L Script Procedure: DYK_COMPUTE_FORMAT_BNW_RESULT.

The input to this table is control_table, which is again a Table type. The control_table holds the column names and IDs of the measure and dimensions in each combination. This helps in changing the column headers from the input table into a row value in the final DYK output.

These column names are now associated with outlier values and add up to the final result. Every row of outlier output is merged with the every row of control_table.

Also, an additional column Column_Spec is populated, which holds the matched value of each outlier value. This column mainly comprises the name of the dimension(s) responsible for making this measure an outlier. This can be helpful when the user selects to view a next infoblock for that search request.

The dyk_insight column holds the actual insight. The final insight is framed by using the data in other columns in the output. The insight actually mentions whether the outlier is high or low, and states the names of the measures and values of the dimension. (Since the insight typically arises from more than one dimension, it may otherwise be difficult to identify the relevant dimension from the dataset, without accessing the actual outlier detection algorithm calling for specialized statistical knowledge).

FIGS. 6A-B show a code snippet for the BoxandWhisker sub-procedure according to an embodiment. FIGS. 7A-D show a code snippet for formatting the BoxandWhisker output using LScript according to an embodiment.

The following is an example of an outlier in the context of searching a database containing sales information for different lines of clothing:

“Store_Sales” is HIGH, when “Lines” is CLOTHS, “Category” is T-SHIRT, and “City” is NEWYORK, where:

“Store_Sales” is the Measure;

“Lines”, “Category”, “City” are dimensions; and

CLOTHS, T-SHIRT, and NEWYORK are the values of these respective dimensions.

The Percentage sub-procedure is also shown in FIG. 2. That algorithm allows determination if X % (or below) of dimensions are contributing to Y % (or more) of measure(s).

The algorithm of the Percentage sub-procedure may afford sensible insights using this algorithm. For example, an insight indicating that 15% of a CITIES dimension is contributing to 75% of a REVENUE measure, may be valuable in identifying profitable sales venues.

The following pseudo code may be useful to understand design of an algorithm for the Percentage sub-procedure.

1. Sort the input in the ascending order of the measure. 2. Compute the percentage value of measure for each dimension. 3. Compute the Cumulative Percentage (CP) for every row. CP is the sum of the percentages till that row. 4. Now, query for the rows whose CP is less than the set limit As an example, for a CP of 60%, the query returns dimensions contributing up to 60% of measure. 5. Now compute the percentage of dimensions contributing to the 60% of Measure. This percentage has to be below the set limit (for example 20%). 6. If the percentage of dimensions is above 20%, then the data is discarded as it will not offer a particularly valuable statistical analytical insight. 7. If the percentage of dimensions is below 20%, then the statistical insight is considered valuable. 8. A scoring logic can be used here to score the insight. To score an insight, divide the set limit (20% in this case) into 5 units. Lower the percentage of dimensions contributing to 60% of measure, higher its score should be. So, if the percentage of dimensions falls under the range 1 to 4, then the score of the insight is 5; if the percentage falls under the range 4 to 8, then the score is 4. Similarly, if the range is 8 to 12 then score is 3. If the range is 12 to 16 then score is 2. If the range is 16 to 20 then the score is 1. 9. Finally, the insight is formatted into a proper text to be displayed in the UI. This algorithm is used with the 1M*1D, as a limit is defined on the dimension.

An embodiment of the actual SQL Procedure is shown in FIGS. 8A-B. FIGS. 9A-B show the code snippet for formatting the output of the Percentage sub-procedure according to an embodiment.

Example

FIG. 10 is a view showing a sample dataset (Sales_Store/420000 rows) including the store and customer details, where:

DATASET ID: 4FBC94EF77EF8112E10000000A358198.

FIG. 11 is a Result View showing DYK statistical analytical insights generated in fourteen seconds, for this sample dataset.

Embodiments may address one or more issues arising from the operation of analysis tools. One such problem is handling large combinations.

Conventional execution of all the sub-procedures in DYK may consume time, if the number of combinations returned from the DIE is large. This undesirably increases the response time in the client.

Embodiments may avoid this delay by performing filtering. Specifically, the DIE is configured to provide statistically valid combinations of a given dataset, using data mining algorithms.

To reduce effort, embodiments filter the DIE combinations to consider only unique combinations. For Example, with a combination of a measure “M1” and dimensions “D1”, “D2”, and “D3”, the possible combinations from DIE could be “M1D1D2D3”, “M1D1D3D2”, “M1D2D3D1”, and “M1D3D2D1”.

For the purposes of DYK, however, all four combinations produce the same output. Hence it is sufficient to take one unique combination for same set of measures and dimensions.

Thus according to an embodiment, only one out of the four combinations is picked for DYK as a unique combination. This may be done in a manner similar to doing “Group By” in SQL statement, where order in the Group By clause doesn't matter.

In this particular example, a number of combinations is reduced from four to one. When this refinement is performed over an entire dataset, the number of combinations is significantly reduced.

Moreover, various trials have indicated that more than 80% of the time the refined number of combinations does not exceed twenty (20). Hence, a number of combinations may be fixed to that number.

Taken alone or in combination, these filtering approaches serve to improve the performance of DYK generation process.

Another issue that may be arise in the conventional use of the DYK tool for data analysis, is the expenditure of significant effort for maintenance and housekeeping for DYK physical tables. Specifically, generating DYK offline as a separate thread without being included along with an actual business case, calls for storing the insights in physical tables in advance. Such an approach would also call for supporting tables to associate the insights with the dataset of a user.

Generating insights in this manner can lead to one or more of:

a significant maintenance effort with regular housekeeping activities to store the insights;

a need to lock the tables whenever multiple users try to update the same table;

a need to handle race conditions a user is generating insights from a different session; and

an inability to generate the data at real time, causing the data to be outdated.

Embodiments may address one or more of these issues by executing the master procedure at runtime. Since tables used for generating insights are Table types, there is no need for physical tables. The computations can be performed in memory.

Moreover, sub-procedures such as BoxandWhisker, Percentage, and associated formatting procedures, may be written in a generic way. Hence, there are only copy of these procedures for the entire schema. Thus while the master DYK generation procedure is created per User and per dataset, the algorithm procedures (e.g. BoxandWhisker and Percentage) are generic. The master DYK generation procedure(s) use the same copy of the algorithm procedures. So, a single copy of algorithm objects is maintained in the DB schema.

In addition, the master procedure may be designed to ensure that sub procedure calls are parallelized, and it is free of physical tables. This can reduce or eliminate maintenance effort.

Runtime execution of the mater procedure also allows the analysis tool to operate on large datasets with high performance, and to provide data at near real time.

Another issue that may be associated with conventional operation of the DYK analysis tool, is handling of input data from different sizes of measure-dimension combinations. Specifically, the dimension values are used to construct the insights.

Specifically, the dimension values are used to construct the insights. However, the master procedure itself is created at runtime, and measure-dimension combinations are also obtained at runtime.

The number of dimensions in each combination varies from 1 to n, and it is indefinite. That is, the number of dimensions in each combination is not the same. The number of dimensions may range as 1, 2, or 3. But while storing the input data for executing the algorithms based on these combinations, the number of columns should be same. Hence a generic format of the query may be used to fetch the data for any size of the combination. Since these dimension values are to be stored in the input table which will be processed further for outlier and percentage calculation, the input table definition differs for each size of combination and with each different dimension names.

Handling this situation in a conventional manner would require input tables matching each combination and dimension name. This would call for many condition checks in the master procedure to identify the right one, possibly degrading performance of the analysis tool.

It is generally acknowledged that human users have trouble visualizing or interpreting data for more than three dimensions. This may be attributable to the difficulty in depicting analysis results for more than three dimensions, on a two-dimensional medium such as a computer screen or a sheet of paper.

In recognition of this limited ability of users to process analytical results with excessive dimensions, particular embodiments may limit a combination length to a maximum of four. In such embodiments, every combination may have a single measure, and the dimension count varies from one to three.

Accordingly, issues associated with the use of multiple table definitions, may be resolved through use of a generic table definition with four generic columns Below is one table definition for the input data table:

create type DYK_Input_DataSet as TABLE(“VALUE” DOUBLE,“DIM1” VARCHAR(1000),“DIM2” VARCHAR(1000),“DIM3” VARCHAR(1000));

Here, the VALUE column corresponds to the measure. DIM1,DIM2,DIM3 correspond to the dimension.

Thus for any number of dimensions in the combination, the input data table holds three columns for dimension. For combinations having a dimension count of less than three, the DIM2 and DIM3 columns may contain repeated values of DIM1.

In order to map these DIM1,DIM2,DIM3 to their actual column names, for every iteration of the combination another generic table called control_table is populated with actual column names at runtime. Below is the definition of the control_table.

create type DYK_CNTRL_TABLE as TABLE(“COLUMN_NAME” VARCHAR(100),“COLUMN_OID” BIGINT);

The approach just described not only simplifies the design, simple but also improves the performance of the insight generation.

Execution of the DYK generation procedure is described in connection with FIG. 12. FIG. 12A provides a chart of the corresponding process flow 1250.

Specifically, when a user 1200 (e.g. a Web Client) clicks on an Infoblock (i.e. a search result), a DYK search request 1202 is sent 1252 from the client. This search request includes the Infoblock XML.

The request is handled by the DYK Search application 1204. The following are steps performed by the DYK search application in order to return the response to the client.

The DYK search application parses 1254 the measures and dimensions from the XML. These parsed measures and dimensions are employed 1256 as column IDs in a search control table specific to a user. The Session ID and the Request ID are put against these Column IDs.

The ResultView is then queried 1258, and the Session ID and the Request ID are passed as parameters 1208. The query of the Result View triggers the execution 1260 of the DYK GEN master procedure.

After executing the sub-procedure algorithms (i.e. BoxandWhisker, Percentage) for the combinations, the master procedure picks up only those insights having the columns present in the search control table for that particular user, against the passed ‘Session ID’ and ‘Request ID’.

The procedure collects 1262 all the DYK insights into one table type. The final score of insights is calculated 1264 by multiplying the algorithm score of the insights with the number of columns it has in common with the request.

Finally, ‘N’ number of insights are returned 1266 by the Result View query starting from ‘X’. N is the number of insights requested from the Client, and X is the start index mentioned in the request.

As described above, insights may be filtered for the input columns from the request. Ordinarily, however, all possible insights may not be sent to the user as a response. Rather, embodiments may rank insights according to their importance, returning to the user only the top N insights (where N is the number requested by the Client).

Accordingly, embodiments may score individual insights based upon ‘Partial Match’ and ‘Full Match’ techniques with respect to the input columns Specifically, each insight is generated for a set of 1+n columns (1 measure, n dimensions).

If this set of columns completely matches the set of columns sent as input, then it is a ‘Full Match’. If this set or part of this set, matches only a part of the set of input columns, then it is a ‘Partial Match’.

In both the Full Match and Partial Match cases, the individual score of the insight (which is generated by the algorithm), is multiplied with the number of matching columns to generate a final score. So, if Y is the individual score of the insight, and Z is the total number of matching columns between the input columns and the columns for which the insight is generated, then the final score may be computed using Y*Z.

Once the final score is generated for all the insights, the insights are sorted on the descending order of the final score. From this set, as many insights are returned 1266 to the user as a ResultSet 1210 as are requested by the client.

The insights may be displayed to the user in the DYK Response 1212 as “Key Information” in the client interface along with the statistical analysis insights. FIG. 13 shows such Key Information presented to the left of results in bar chart format. FIG. 14 shows Key Information presented to the left of results in the format of a plotted graph.

FIG. 15 illustrates hardware of a special purpose computing machine configured to perform insight generation according to an embodiment. In particular, computer system 1500 comprises a processor 1502 that is in electronic communication with a non-transitory computer-readable storage medium 1503. This computer-readable storage medium has stored thereon code 1505 corresponding to an insight analysis tool (e.g. DYK). Code 1504 corresponds to a DIE. Code may be configured to reference data stored in a database of a non-transitory computer-readable storage medium, for example as may be present locally or in a remote database server. Software servers together may form a cluster or logical network of computer systems programmed with software programs that communicate with each other and work together in order to process requests.

In conclusion, embodiments may seek to generate statistical analytical insights from a dataset in a manner that relies upon the speed and power afforded by an in-memory database. The DYK generation procedure has been designed so that the execution is parallelized.

Generation of the statistical analytical insights at runtime, on request, reduces the maintenance, as the generated insights are not required to be stored.

The use of Full/Partial Match and filtering, help retrieve the insights for only the input columns, in an efficient manner.

Utilization of the Result View, makes it easier to operate on the output of the master procedure, and to retrieve the desired insights in the required order.

By using the DIE, embodiments ensure that combinations considered for generation of analytical insights, are valid and meaningful.

Embodiments may exhibit both adaptability and flexibility. In particular, embodiments may be plugged to an application that is using the same technology platform. Embodiments may be flexible in that different algorithms to generate insights can be added or removed as sub-procedures.

Finally, use of the ranking technique helps to ensure that the insights are prioritized, and that the high priority insights are returned to the user.

An example computer system 1610 is illustrated in FIG. 16. Computer system 1610 includes a bus 1605 or other communication mechanism for communicating information, and a processor 1601 coupled with bus 1605 for processing information. Computer system 1610 also includes a memory 1602 coupled to bus 1605 for storing information and instructions to be executed by processor 1601, including information and instructions for performing the techniques described above, for example. This memory may also be used for storing variables or other intermediate information during execution of instructions to be executed by processor 1601. Possible implementations of this memory may be, but are not limited to, random access memory (RAM), read only memory (ROM), or both. A storage device 1603 is also provided for storing information and instructions. Common forms of storage devices include, for example, a hard drive, a magnetic disk, an optical disk, a CD-ROM, a DVD, a flash memory, a USB memory card, or any other medium from which a computer can read. Storage device 1603 may include source code, binary code, or software files for performing the techniques above, for example. Storage device and memory are both examples of computer readable mediums.

Computer system 1610 may be coupled via bus 1605 to a display 1612, such as a cathode ray tube (CRT) or liquid crystal display (LCD), for displaying information to a computer user. An input device 1611 such as a keyboard and/or mouse is coupled to bus 1605 for communicating information and command selections from the user to processor 1601. The combination of these components allows the user to communicate with the system. In some systems, bus 1605 may be divided into multiple specialized buses.

Computer system 1610 also includes a network interface 1604 coupled with bus 1605. Network interface 1604 may provide two-way data communication between computer system 1610 and the local network 1620. The network interface 1604 may be a digital subscriber line (DSL) or a modem to provide data communication connection over a telephone line, for example. Another example of the network interface is a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links are another example. In any such implementation, network interface 604 sends and receives electrical, electromagnetic, or optical signals that carry digital data streams representing various types of information.

Computer system 1610 can send and receive information, including messages or other interface actions, through the network interface 1604 across a local network 1620, an Intranet, or the Internet 1630. For a local network, computer system 1610 may communicate with a plurality of other computer machines, such as server 1615. Accordingly, computer system 1610 and server computer systems represented by server 1615 may form a cloud computing network, which may be programmed with processes described herein. In the Internet example, software components or services may reside on multiple different computer systems 1610 or servers 1631-1635 across the network. The processes described above may be implemented on one or more servers, for example. A server 1631 may transmit actions or messages from one component, through Internet 1630, local network 1620, and network interface 604 to a component on computer system 1610. The software components and processes described above may be implemented on any computer system and send and/or receive information across a network, for example.

The above description illustrates various embodiments of the present invention along with examples of how aspects of the present invention may be implemented. The above examples and embodiments should not be deemed to be the only embodiments, and are presented to illustrate the flexibility and advantages of the present invention as defined by the following claims. Based on the above disclosure and the following claims, other arrangements, embodiments, implementations and equivalents will be evident to those skilled in the art and may be employed without departing from the spirit and scope of the invention as defined by the claims. 

What is claimed is:
 1. A computer-implemented method comprising: causing an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database; causing the insight analysis tool to process the input according to a master procedure comprising a sub-procedure, in order to generate an insight; and causing the insight to be displayed to a user.
 2. A method as in claim 1 wherein: the input comprises a result of a user query to the in-memory database; and the insight analysis tool is caused to process the input during a runtime of the user query.
 3. A method as in claim 3 wherein the insight analysis tool is caused to process the input according to a parameter of the user query.
 4. A method as in claim 1 wherein the insight analysis tool is further configured to: generate a plurality of insights from the input; and rank the insight relative to the plurality of insights.
 5. A method as in claim 1 wherein the insight analysis tool is further configured to: receive a plurality of measure/dimension combinations; and filter the plurality of measure/dimension combinations to generate the insight.
 6. A method as in claim 5 wherein: the plurality of measure/dimension combinations comprise multiple dimensions; and filtering the plurality of measure/dimension combinations comprises limiting a number of insights, limiting a number of dimensions, and/or identifying unique measure/dimension combinations by disregarding an order in which dimensions occur.
 7. A method as in claim 1 wherein the sub-procedure comprises outlier detection.
 8. A non-transitory computer readable storage medium embodying a computer program for performing a method, said method comprising: causing an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database; causing the insight analysis tool to process the input according to a master procedure comprising a sub-procedure, in order to generate an insight; and causing the insight to be displayed to a user.
 9. A non-transitory computer readable storage medium as in claim 8 wherein: the input comprises a result of a user query to the in-memory database; and the insight analysis tool is caused to process the input during a runtime of the user query.
 10. A non-transitory computer readable storage medium as in claim 9 wherein the insight analysis tool is caused to process the input according to a parameter of the user query.
 11. A non-transitory computer readable storage medium as in claim 8 wherein the insight analysis tool is further configured to: generate a plurality of insights from the input; and rank the insight relative to the plurality of insights.
 12. A non-transitory computer readable storage medium as in claim 8 wherein the insight analysis tool is further configured to: receive a plurality of measure/dimension combinations; and filter the plurality of measure/dimension combinations to generate the insight.
 13. A non-transitory computer readable storage medium as in claim 12 wherein: the plurality of measure/dimension combinations comprise multiple dimensions; and filtering the plurality of measure/dimension combinations comprises limiting a number of insights, limiting a number of dimensions, and/or identifying unique measure/dimension combinations by disregarding an order in which dimensions occur.
 14. A non-transitory computer readable storage medium as in claim 8 wherein the sub-procedure comprises outlier detection.
 15. A computer system comprising: one or more processors; a software program, executable on said computer system, the software program configured to: cause an insight analysis tool to receive from a data inference engine, an input comprising a measure/dimension combination of a dataset stored in an in-memory database; cause the insight analysis tool to process the input according to a master procedure comprising a sub-procedure, in order to generate an insight; and cause the insight to be displayed to a user.
 16. A computer system as in claim 15 wherein: the input comprises a result of a user query to the in-memory database; and the insight analysis tool is caused to process the input during a runtime of the user query.
 17. A computer system as in claim 16 wherein the insight analysis tool is caused to process the input according to a parameter of the user query.
 18. A computer system as in claim 15 wherein the insight analysis tool is further configured to: generate a plurality of insights from the input; and rank the insight relative to the plurality of insights.
 19. A computer system as in claim 15 wherein the insight analysis tool is further configured to: receive a plurality of measure/dimension combinations; and filter the plurality of measure/dimension combinations to generate the insight.
 20. A computer system as in claim 19 wherein: the plurality of measure/dimension combinations comprise multiple dimensions; and filtering the plurality of measure/dimension combinations comprises limiting a number of insights, limiting a number of dimensions, and/or identifying unique measure/dimension combinations by disregarding an order in which dimensions occur. 